There are many ways to create animation. In an extremely simple approach, someone types into a computer the coordinates of simple shapes, and a computer program stores the input as objects and then manipulates the objects. Obviously, such an approach is not practical for full use of animation capabilities today and would not be useful to artists who may want to spend time on creative approaches and input rather than tedious details. A much better animation creation system would allow for the artist to input animation details in a natural fashion and then work with those inputs.
One conventional approach is to provide the artist with a digitizing tablet, which outputs each stroke made by the artist as a discrete element, thus representing line drawings as a collection of vectors. From there, a graph of relationships of vectors might be generated and used in the animation process to, for example, keep connections between lines that collectively represent some closed bound of an object. For example, a collection of lines that represent a virtual character's body parts can be graphed so that arms and legs remain attached as the virtual character moves and that individual lines that represent connected elements remain connected.
For example, if there is a line in an image that represents the surface of a forearm and another line that represents the start of an elbow, the elbow line should remain connected to the forearm line even as the forearm moves, in order for the animation to make sense. This connectedness can be enforced by the animation system by having constraints on the coordinates in a virtual space for some of the lines representing strokes. Alternatively, the artists can edit each frame of an animation to reconnect lines that get disconnected, but this can be tedious and is unnecessary when the animation system can maintain the connectivity over hundreds of frames with little difficulty.
Of course, in order for the animation system to do this properly, the images being animated need to be expressed as strokes and/or objects (i.e., “vectors”) rather than just arrays of pixel color values (“pixelated images”). However, if the input is a pixelated image, such as a hand-drawn and scanned drawing, or other inputs that do not contain the stroke/object structures, the input might simply be arrays of pixel color values with no indication of connectedness. Thus, it is often necessary to convert or generate stroke information and/or object information from an array of pixel color values.
The most common representations for digitization of images—raster and vector graphics—have complementary but mutually exclusive properties. On the one hand, scanned raster images capture details of an image down to the pixel level, but image editing is restricted to low-level pixel manipulation as well. On the other hand, vector graphics define an abstraction of the image content that allows for sophisticated editing operations, but the abstraction process generally loses the pixel-level detail.
In 2D animation the separation of these two representations is a fundamental issue. 2D animation drawings are traditionally created using pencil sketches and ink drawings on paper. These line drawings are then scanned and vectorized for further processing in the digital movie production pipeline. Advanced 2D animation tools, such as automatic inbetweening, inking, and painting, as well as realistic digital drawing tools are forced to adopt one of the two representations and convert between them. This conversion process generally decreases quality and loses many properties of the original drawings, such as stroke texture and subtle details.
One approach to the generation of a vectorized image is to have an artist view an overlay of a scanned image and “draw” an overlay of the strokes using a digitizing tablet. This can be tedious itself and it might not capture all of the expressiveness of the original artist.
There are conventional processes for “vectorizing” an image, i.e., generating a representation of a pixel array representing an image, such as a scan of a physically drawn image, wherein the representation is list, table, array, etc. of strokes, wherein each stroke data element might be represented by two endpoints and a set of polynomial coefficients, thus defining the path of the stroke. In many cases, the results of non-manual vectorization are less than desirable for good quality animation processes. Most existing methods for vectorization perform only a low-level analysis of the input image, without considering the global drawing structure. This manifests in errors such as wrong estimates of centerlines, inaccurate junction points, and merging of nearby strokes, which is a considerable problem for applications such as automatic inbetweening.
Thus, it would be useful to have a programmable system for generating stroke and object sets from pixelated images, but that also allows for artist inputs to the generating process so as to preserve the intended expressiveness desired for the final animation sequence.